home *** CD-ROM | disk | FTP | other *** search
/ GameStar 2003 April / Gamestar_50_2003-04_cd1.bin / Dema / echelonww_demo.exe / {app} / Modules / Menu15_TestSuite.py < prev    next >
Text File  |  2003-01-27  |  28KB  |  763 lines
  1. import testutil
  2. import unittest
  3.  
  4. from utils import *
  5.  
  6. from utils.mergeTrees import mergeTrees
  7.  
  8. from AT.makeTable import makeTable
  9.  
  10. import sys
  11. import os
  12. import shutil
  13.  
  14. import Menu15_Mock
  15.  
  16. import Mock
  17.  
  18. from Menu15 import CreateDB
  19.  
  20. from Menu15 import UDB
  21.  
  22.  
  23. class Menu15_Checker:
  24.  
  25.     def checkEnabled(self, controls, enabled = 1, msg = ''):
  26.         if type(controls) is str:
  27.             c = controls
  28.             asserter = (self.assert_, self.failIf)[not enabled]
  29.             asserter(self.ctrls._isEnabled(c), str(c) + ' is %s; '%('disabled', 'enabled')[not enabled] + msg)
  30.             return
  31.             
  32.         for c in controls:
  33.             self.checkEnabled(c, enabled, msg)
  34.             
  35.     def checkDisabled(self, *controls):
  36.         for c in controls:
  37.             self.failIf(self.ctrls._isEnabled(c))
  38.             
  39.     def checkSelection(self, control, selection):
  40.         self.assert_(self.ctrls._isShown(control))
  41.         self.assertEqual(self.getControl(control).getSelection(), selection)
  42.  
  43.     def checkSelectionItem(self, control, item):
  44.         self.assert_(self.ctrls._isShown(control))
  45.         widget = self.getControl(control)
  46.         selection = widget.getSelection()
  47.         self.assertEqual(item, widget.Items[selection])
  48.  
  49.     def checkNumItems(self, control, num_items):
  50.         items = self.getControl(control).Items
  51.         self.assertEqual(num_items, len(items))
  52.  
  53.     def checkItemEnabled(self, control, index, enabled):
  54.         self.assertEqual(enabled, self.getControl(control).Enableds[index])
  55.  
  56.     def checkItems(self, control, ref_items):
  57.         items = self.getControl(control).Items
  58.         self.assertEqual(len(ref_items), len(items))
  59.         for ref_item, item in zip(ref_items, items):
  60.             if ref_item is not None:
  61.                 if type(ref_item) is str:
  62.                     self.assertEqual(ref_item, item)
  63.                 else:
  64.                     key, suff, params = ref_item
  65.                     self._checkLocalized(item, key, suff, params)
  66.  
  67.     def checkItemsSet(self, control, items):
  68.         self.assertSetsEqual(self.getControl(control).Items, items)
  69.  
  70.     def checkAlphabet(self, control, alphabet):
  71.         self.assertEqual(getattr(self.ctrls.Alphabet, alphabet.capitalize()),
  72.                          self.getControl(control)._alphabet)
  73.  
  74.     def checkMaxStrLen(self, control, len):
  75.         self.assertEqual(len, self.getControl(control)._max_str_len)
  76.         
  77.     def checkText(self, control, text):
  78.         def eq(menu, checked_text):
  79.             self.assertEqual(text, checked_text)
  80.         self.evalText(control, eq)
  81.         
  82.     def evalText(self, control, check):
  83.         self.checkShown(control)
  84.         check(self, self.getControl(control).Text)
  85.  
  86.     def evalCaption(self, control, check):
  87.         self.checkShown(control)
  88.         check(self, self.ctrls._getCaption(control))
  89.  
  90.     def evalItem(self, control, index, check):
  91.         items = self.getControl(control).Items
  92.         check(self, items[index])
  93.         
  94.     def checkListsLinked(self, name0, name1):
  95.         def assertLinked(name0, name1):
  96.             l0 = self.getControl(name0)
  97.             l1 = self.getControl(name1)
  98.             self.assert_(l1 in l0.links, 'List '+name0+' not linked '+name1)
  99.         assertLinked(name0, name1)
  100.         assertLinked(name1, name0)
  101.  
  102.     def _checkLocalized(self, text, control, suff, expected_params):
  103.         screen = control.split('.')[0]
  104.         self.checkShown(control)
  105.         expected_key = control
  106.         if suff:
  107.             expected_key += '.'+suff
  108.         self.assertEqual(screen, text.folder)
  109.         self.assertEqual(expected_key, text.key)
  110.         self.checkTextParams(expected_params, text.params)
  111.  
  112.         for param in ('PlayerName', 'PlayerCallsign'):
  113.             ('%('+param+')s')%text.params
  114.  
  115.     def checkLocalizedKey(self, control, expected_key):
  116.         text = self.getControl(control).Text 
  117.         screen = control.split('.')[0]
  118.         self.checkShown(control)
  119.         self.assertEqual(screen, text.folder)
  120.         self.assertEqual(expected_key, text.key)
  121.             
  122.     def checkTextParams(self, expected_params, params):
  123.         for param, value in expected_params.items():
  124.             self.assertEqual(value, params[param], ''.join(("param:", `param`, ', expected:', `value`, ', found:', `params[param]`)))
  125.  
  126.     def checkLocalizedText(self, control, suff, expected_params):
  127.         self._checkLocalized(self.getControl(control).Text, control, suff, expected_params)
  128.             
  129.     def checkLocalizedCaption(self, control, suff, expected_params):
  130.         self._checkLocalized(self.ctrls._getCaption(control), control, suff, expected_params)
  131.         
  132.     def checkSliderValue(self, control, value):
  133.         self.checkShown(control)
  134.         self.assertEqual(self.getControl(control).value, value)
  135.  
  136.     def checkSliderContinuous(self, control):
  137.         self.checkShown(control)
  138.         self.checkSliderNumSegments(control, 0)
  139.         
  140.     def checkSliderNumSegments(self, control, value):
  141.         self.checkShown(control)
  142.         if hasattr(self.getControl(control), 'num_segments'):
  143.             self.assertEqual(self.getControl(control).num_segments, value)
  144.         else:
  145.             self.assertEqual(0, value)
  146.     
  147.     def checkChecker(self, control, value):
  148.         self.checkShown(control)
  149.         self.assertEqual(self.getControl(control).checked, value)
  150.  
  151.     def checkShownOnly(self, controls):
  152.         self.assertSetsEqual(self.ctrls._getShown(), controls)
  153.     
  154.     def checkShown(self, *args):
  155.         for arg in args:
  156.             if type(arg) is str:
  157.                 self.assert_(self.ctrls._isShown(arg), '"%s" not shown'%(str(arg), ))
  158.             else:
  159.                 self.checkShown(*arg)
  160.  
  161.     def checkNotShown(self, controls):
  162.         for control in controls:
  163.             self.failIf(self.ctrls._isShown(control), '"%s" in shown'%(str(control), ))
  164.  
  165.     def checkFocus(self, control):
  166.         self.assertEqual(control, self.ctrls._focus)
  167.  
  168.     def checkCaption(self, control, caption):
  169.         self.assertEqual(self.ctrls._getCaption(control), caption)
  170.     
  171.     def checkGame(self, game, _gameset, mission, host):
  172.         gameset = self.fullGamesetPath(_gameset)
  173.         self.assertEqual(gameset, game.gameset)
  174.         self.assertEqual(mission, game.mission)
  175.         self.assertEqual(host, game.host)
  176.  
  177.     def checkOpenedGame(self, _gameset, mission, host):
  178.         game = self.Game._opened_game
  179.         self.checkGame(game, _gameset, mission, host)
  180.  
  181.     def checkStartedGame(self, *value):
  182.         if len(value)==1:
  183.             self.assertEqual(value[0], self.Game._started_game)
  184.         else:
  185.             self.checkGame(self.Game._started_game, value[0], value[1], 0)
  186.  
  187.     def checkResumedGame(self, value):
  188.         self.assertEqual(value, self.Game._resumed_game)
  189.  
  190.     def checkNotResumedGame(self):
  191.         self.assertRaises(AttributeError, getattr, self.Game, '_resumed_game')
  192.  
  193.     def checkStartedMission(self, event_name):
  194.         self.assertEqual(self.Game._started_game.mission, event_name)
  195.  
  196.     def checkStartedProfile(self, value):
  197.         self.assertEqual(self.Game._started_game.profile, value)
  198.  
  199.     def checkGlobalTriggers(self, triggers, access_rules = {}):
  200.         profile = UDB.open(self.getProfilePath(self.Game._started_game.profile), 1).toPython()
  201.         self.assertEqual(dict(profile['CurrentMission']['GlobalTriggers']),
  202.                          triggers)
  203.         self.assertEqual(dict(profile['CurrentMission']['AccessRules']),
  204.                          access_rules)
  205.         self.assertEqual(len(profile['CurrentMission'].keys()), 2)
  206.  
  207.     def checkNoObjectives(self, primary):
  208.         profile = UDB.open(self.getProfilePath(self.Game._started_game.profile), 1).toPython()
  209.         m = profile['CurrentMission']
  210.         try:
  211.             m['PrimaryObjectives']
  212.         except KeyError:pass
  213.         else:
  214.             self.fail('must raise KeyError')
  215.  
  216.  
  217.     def checkProfile(self, pname, value, value_type, folder, opt_class, opt_name):
  218.         profile = UDB.open(self.getProfilePath(pname), 1)
  219.         d = profile[folder][opt_class][opt_name]
  220.         self.assertEqual(d, value)
  221.         self.assertEqual(type(d), value_type)
  222.         
  223.     def checkOption(self, pname, value, value_type, opt_class, opt_name):
  224.         self.checkProfile(pname, value, value_type, 'Options', opt_class, opt_name)
  225.  
  226.     def checkProfileFolders(self, pname, data, *folders):
  227.         profile = UDB.open(self.getProfilePath(pname), 1)
  228.         d = profile
  229.         for f in folders: d = d[f]
  230.         d = d.toPython()
  231.         self.assertEqual(d, data)
  232.         
  233.     def checkProfileOptions(self, pname, data, options_class):
  234.         self.checkProfileFolders(pname, data, 'Options', options_class)
  235.  
  236.     def checkProfileServer(self, pname, data):
  237.         self.checkProfileOptions(pname, data, 'Server')
  238.  
  239.     def checkProfileControls(self, pname, data, *folders):
  240.         self.checkProfileFolders(pname, data, 'Controls', *folders)
  241.  
  242.     def checkProfileKeys(self, pname, data):
  243.         self.checkProfileControls(pname, data, 'Keys')
  244.         
  245.     def checkProfileKeysActions(self, pname, data):
  246.         self.checkProfileControls(pname, data, 'Keys', 'ActionsList')
  247.         
  248.     def checkProfileDevices(self, pname, data):
  249.         self.checkProfileControls(pname, data, 'Devices')
  250.         
  251.     def checkAppliedCraft(self, craft_selection):
  252.         self.Game.assertCraftSelection(craft_selection)
  253.  
  254.     def checkVideo(self, video_name):
  255.         self.assertEqual(self.Game.Video, video_name)
  256.         
  257.     def checkQuited(self):
  258.         self.assert_(self.Game.quited)
  259.  
  260.     def checkNotQuited(self):
  261.         self.failIf(self.Game.quited)
  262.  
  263.     def checkProfiles(self, *profiles):
  264.         name_ext = [os.path.splitext(fname) for fname in os.listdir(self.profiles_folder.path)]
  265.         self.assertSetsEqual([name for name, ext in name_ext if '.epp'==ext],
  266.                              profiles)
  267.  
  268.     def checkModifier(self, name, value):
  269.         self.assertEqual(value, getattr(self.Game.modifiers, name))
  270.  
  271.     def checkEndCaptureKeys(self):
  272.         self.failIf(self.ctrls.capturing_keys)
  273.  
  274.     def checkServersRefreshingFrom(self, _from):
  275.         self.assertEqual(_from, self.Game._refreshing_from)
  276.  
  277.     def checkConnectTo(self, *addr):
  278.         self.assertEqual(addr, tuple(self.Game._connectTo))
  279.  
  280.     def checkDisconnected(self, *addr):
  281.         self.failIf(not self.Game._disconnected)
  282.  
  283.     def checkNotDisconnected(self):
  284.         try:
  285.             self.Game._disconnected
  286.         except AttributeError:pass
  287.         else:
  288.             self.failIf(self.Game._disconnected)            
  289.  
  290.     def checkViewport(self, name):
  291.         self.assertEqual(name, self.ctrls._viewport)
  292.  
  293.     def checkPreview_objects(self, *objects):
  294.         self.assertEqual(objects, tuple(self.Preview.objects))
  295.  
  296.     def checkPreview_craft(self, name, weapons):
  297.         self.assertEqual(name, self.Preview.craft.name)
  298.         self.assertEqual(list(weapons), self.Preview.craft.slots)
  299.  
  300.     def checkGamma(self, value):
  301.         self.assertEqual(value, self.Game._gamma)
  302.  
  303.     def checkGeneralVolume(self, value):
  304.         self.assertEqual(value, self.Game._GeneralVolume)
  305.  
  306.     def checkMenuEffectsVolume(self, value):
  307.         self.assertEqual(value, self.Game._MenuEffectsVolume)
  308.  
  309.     def checkMenuMusicVolume(self, value):
  310.         self.assertEqual(value, self.Game._MenuMusicVolume)
  311.  
  312. class Menu15_Test(unittest.TestCase, testutil.testutil):
  313.     UseRealText = 0
  314.  
  315.     def startHook(self, game):
  316.         if self.deferred_showEngbay:
  317.             self.menu.showEngBay(*self.deferred_showEngbay)
  318.             self.deferred_showEngbay = 0
  319.  
  320.     def addServer_hook(self, servers):
  321.         map(self.menu.addServer, servers)
  322.  
  323.     def reloadText(self):
  324.         import Mock.Text
  325.         reload(Mock.Text)
  326.         self.text = Mock.Text
  327.         self.text.data = {}
  328.  
  329.     def setUp(self):
  330.  
  331.         self.Preview = Menu15_Mock.initPreview()
  332.         
  333.         self.Game = Menu15_Mock.initGame()
  334.         self.Game.startHook = self.startHook
  335.         self.Game.addServer_hook = self.addServer_hook
  336.         
  337.         if not self.UseRealText:
  338.             import Mock.Text
  339.             sys.modules['Menu15.Text'] = Mock.Text
  340.  
  341.         import copy
  342.         self.modules = copy.copy(sys.modules)
  343.  
  344.         self.data_folder = None
  345.         self.profiles_folder = None
  346.  
  347.         self.menu = None
  348.  
  349.     def reset(self):
  350.         self.version = 'last'
  351.  
  352.         sys.modules.clear()
  353.         sys.modules.update(self.modules)
  354.  
  355.         self.data_folder = testutil.TempFolder()
  356.         shutil.copy('TestData\Menu.dat', self.data_folder.path)
  357.  
  358.         self.profiles_folder = testutil.TempFolder()
  359.         
  360.         self.def_keys_controls = {}
  361.         self.actions_order = ''
  362.         self.actions = {}
  363.         
  364.         self.Preview.reset()
  365.         
  366.         self.Game.reset()
  367.         self.Game.Path = self.data_folder.path
  368.         self.Game.ProfilesFolderPath = self.profiles_folder.path
  369.  
  370.         self.game_data = {'ActionsList':{}, 'ActionsOrder':'',
  371.                           'DefaultControls':{'Keys':{},
  372.                                              'Devices':{'Device':2,
  373.                                                        'DeviceSensitivity':0,
  374.                                                        'DeviceDeadZone':0,
  375.                                                        'DeviceInvertY':0,
  376.                                                        'DeviceXasYaw':0,
  377.                                                        'Rudder':0,
  378.                                                        'RudderSensitivity':0,
  379.                                                        'RudderDeadZone':0
  380.                                                        }
  381.                                              },
  382.                           'DefaultOptions':{'Server':{'Name':'DeepBlue',
  383.                                                      'PublishOnGameSpy':0,
  384.                                                      'NumberOfPlayers':13,
  385.                                                      'NumberOfBots':5,
  386.                                                      'NumberOfConnections':30,
  387.                                                      'KillLimit':0,
  388.                                                      'TimeLimit':0,
  389.                                                      'EnableColorNames':0,
  390.                                                      'NeedToConfirmVictories':0,
  391.                                                      'CanStealVictories':0},
  392.                                               'Video':{'Shadows':0,
  393.                                                       'Effects':0,
  394.                                                       'TransparentWater':0,
  395.                                                       'Range':1000.0,
  396.                                                       'ObjectsDetail':1.0,
  397.                                                       'EffectsDetail':1.0,
  398.                                                       'DebrisesDetail':1.0,
  399.                                                       'Gamma':1.0},
  400.                                               'Game':{
  401.                                                     'ShowFriendsName':0, 'ShowFriendsType':0, 'ShowFriendsDist':0,
  402.                                                     'ShowEnemiesName':0, 'ShowEnemiesType':0, 'ShowEnemiesDist':0,
  403.                                                     'ShowLead':0, 'ShowThreat':0, 'UnlimitedArmor':0,
  404.                                                     'UnlimitedAmmo':0, 'NoDamageFromObjects':0,
  405.                                                     'NoDamageFromGround':0, 'NoDamageFromFriends':0,
  406.                                                     'AllowEnemiesName':0, 'AllowEnemiesType':0,
  407.                                                     'AllowEnemiesDist':0, 'Difficulty':0, 'Debug':0},
  408.                                               'Sound':{'GeneralVolume':7,
  409.                                                   'MenuMusicVolume':7,
  410.                                                   'MenuEffectsVolume':7,
  411.                                                   'GameVolume':7,
  412.                                                   'GameHudVolume':7,
  413.                                                   'GameRadioVolume':7,
  414.                                                   'GameCraftEngineVolume':7,
  415.                                                   'GameSoundDetail':0}
  416.                                               }
  417.                           }
  418.         import l10n_params
  419.         self.setGameData(l10n_params.l10n)
  420.         
  421.         self.extended_devices = []
  422.         self.extended_rudders = []
  423.         self.setKilled(0)
  424.  
  425.         self.reloadText()
  426.         
  427.     def exit(self):
  428.  
  429.         self.menu.done()
  430.         self.menu = None
  431.  
  432.         sys.modules.clear()
  433.         sys.modules.update(self.modules)
  434.  
  435.         self.reloadText()
  436.  
  437.         self.Preview.reset()
  438.  
  439.         lastProfile = self.Game.lastProfile
  440.         self.Game.reset()
  441.         self.Game.lastProfile = lastProfile
  442.         self.Game.Path = self.data_folder.path
  443.         self.Game.ProfilesFolderPath = self.profiles_folder.path
  444.         testutil.collectGarbage()
  445.  
  446.     def init(self):
  447.  
  448.         gd = UDB.UDB()
  449.         gd.update(self.game_data)
  450.         UDB.save(self.data_folder.createPath('GameData.dat'), gd)
  451.  
  452.         self.ctrls = Mock.Controls()
  453.         
  454.         self.deferred_showEngbay = 0
  455.  
  456.         self.Game.extended_devices = self.extended_devices
  457.         self.Game.extended_rudders = self.extended_rudders
  458.         
  459.         import Menu15.Main
  460.  
  461.         self.menu = Menu15.Main
  462.         self.menu.setVersion(self.version)
  463.         self.menu.init(self.ctrls)
  464.  
  465.  
  466.         self.update()
  467.  
  468.  
  469.     def getControl(self, name):
  470.         return self.ctrls.get(name)
  471.     
  472.         
  473.     def exec_Press(self, *controls):
  474.         for control in controls:
  475.             self.checkEnabled([control], 1)
  476.             self.failIf(not self.ctrls._isShown(control), control)
  477.             self.ctrls.Pressed = control
  478.             c = self.getControl(control)
  479.             if c.Type is 'Check':
  480.                 c.setChecked(not c.isChecked())
  481.             self.update()
  482.  
  483.     def exec_Select(self, control, selection):
  484.         self.checkEnabled([control], 1)
  485.         self.checkItemEnabled(control, selection, 1)
  486.         self.getControl(control).setSelection(selection)
  487.         self.ctrls.Pressed = control
  488.         self.update()
  489.         
  490.     def setValue(self, control, value):
  491.         self.getControl(control).setValue(value)
  492.         self.ctrls.Pressed = control
  493.         self.update()
  494.         
  495.     def setText(self, control, value):
  496.         self.getControl(control).Text = value
  497.         self.ctrls.Pressed = control
  498.         self.update()
  499.         
  500.     def exec_DoubleClick(self, control, selection):
  501.         self.exec_Select(control, selection)
  502.         self.exec_Select(control, selection)
  503.         
  504.     def update(self):
  505.         self.ctrls.updated = 0
  506.         self.menu.update()
  507.         assert self.ctrls.updated
  508.  
  509.     def fullGamesetPath(self, name):
  510.         return os.path.join(self.Game.getPath(), name)
  511.  
  512.     def setKilled(self, killed):
  513.         self.killed = killed
  514.  
  515.     def showGameResults(self):
  516.         self.saveKilled(self.killed)
  517.         self.saveMissionStatus('completed')
  518.         self.menu.showGameResults()
  519.  
  520.     def runMain(self, profiles):
  521.         self.setProfiles(profiles)
  522.  
  523.         self.init()
  524.  
  525.     def setGameData(self, data):
  526.         self.game_data = mergeTrees(data, self.game_data)
  527.  
  528.     def showEngBay(self, crafts, weapons, def_selection):
  529.         class Craft:
  530.             def __init__(self, c_data):
  531.                 self.__dict__.update(c_data)
  532.                 
  533.             def getName(self):
  534.                 return self.name
  535.  
  536.             def getAllowedWeapons(self, slot):
  537.                 return self.slots[slot]
  538.  
  539.         class Weapon:
  540.             def __init__(self, name):
  541.                 self.name = name
  542.                 
  543.             def getName(self):
  544.                 return self.name
  545.         
  546.         class Selection:
  547.             def __init__(self, craft, slots):
  548.                 self.Craft = craft
  549.                 self.Slots = list(slots)
  550.  
  551.         self.menu.showEngBay(
  552.             dict([(c_idx, Craft(c_data)) for c_idx, c_data in crafts.items()]), 
  553.             dict([(w_index, Weapon(w_data)) for w_index, w_data  in weapons.items()]), 
  554.             Selection(def_selection[0], def_selection[1]))
  555.         self.update()
  556.  
  557.     def defer_showEngBay(self, crafts, weapons, def_selection):
  558.         class Craft:
  559.             def __init__(self, c_data):
  560.                 self.__dict__.update(c_data)
  561.                 
  562.             def getName(self):
  563.                 return self.name
  564.  
  565.             def getAllowedWeapons(self, slot):
  566.                 return self.slots[slot]
  567.  
  568.         class Weapon:
  569.             def __init__(self, name):
  570.                 self.name = name
  571.                 
  572.             def getName(self):
  573.                 return self.name
  574.         
  575.         class Selection:
  576.             def __init__(self, craft, slots):
  577.                 self.Craft = craft
  578.                 self.Slots = list(slots)
  579.  
  580.         self.deferred_showEngbay = (
  581.             dict([(c_idx, Craft(c_data)) for c_idx, c_data in crafts.items()]), 
  582.             dict([(w_index, Weapon(w_data)) for w_index, w_data  in weapons.items()]), 
  583.             Selection(def_selection[0], def_selection[1]))
  584.  
  585.     def setProfiles(self, profiles, last_profile_name = None):
  586.         if last_profile_name is not None:
  587.             self.Game.setLastProfile(last_profile_name)
  588.  
  589.         profiles_folder = self.profiles_folder.path
  590.         if os.path.isdir(profiles_folder):
  591.             shutil.rmtree(profiles_folder)
  592.         os.mkdir(profiles_folder)
  593.  
  594.         from Menu15 import ProfileData
  595.         for name, data in profiles:
  596.             CreateDB.createDbEx(self.getProfilePath(name), 
  597.                                 ProfileData.createProfileData(data))
  598.  
  599.     def clearLastProfile(self):
  600.         self.Game.setLastProfile('')
  601.      
  602.     def setGamesets(self, gamesets):
  603.         self.setGamesetsEx([(name, Menu15_Mock.Campaigns[name]) for name in gamesets])
  604.  
  605.     def setGamesetsEx(self, gamesets):
  606.         import glob
  607.         for path in glob.glob(os.path.join(self.Game.getPath(), '*.gsl')):
  608.             os.remove(path)
  609.  
  610.         for name, data in gamesets:
  611.             CreateDB.createGameset(self.fullGamesetPath(name), data)
  612.  
  613.     def setExtendedDevices(self, devices):
  614.         self.extended_devices = tuple(devices)
  615.  
  616.     def setExtendedRudders(self, rudders):
  617.         self.extended_rudders = tuple(rudders)
  618.         
  619.     def setVersion(self, version):
  620.         self.version = version
  621.  
  622.     def setOpenedGame(self, game):
  623.         self.Game._opened_game = game
  624.         
  625.     def setStartedGame(self, game):
  626.         self.Game._started_game = game
  627.         
  628.     def updateCurrentMission(self, data):
  629.         profile_path = self.getProfilePath(self.Game._started_game.profile)
  630.         profile = UDB.open(profile_path, 0)
  631.         profile['CurrentMission'].update(data)
  632.         UDB.save(profile_path, profile)
  633.         
  634.     def updateCurrentMissionLocal(self, data):
  635.         profile_path = self.getProfilePath(self.Game._started_game.profile)
  636.         profile = UDB.open(profile_path, 0)
  637.         if not profile['CurrentMission'].has_key('Local'):
  638.             profile['CurrentMission']['Local'] = {}
  639.         profile['CurrentMission']['Local'].update(data)
  640.         UDB.save(profile_path, profile)
  641.         
  642.     def setObjectives(self, primary={}, secondary={}, other={}):
  643.         self.updateCurrentMission({'PrimaryObjectives':primary, 
  644.                                           'SecondaryObjectives':secondary,
  645.                                           'OtherObjectives':other})
  646.  
  647.     def setAccessRulez(self, data):
  648.         self.updateCurrentMission({'AccessRules':data})
  649.  
  650.     def setGlobalTriggers(self, triggers):
  651.         self.updateCurrentMission({'GlobalTriggers':triggers})
  652.  
  653.     def setAwards(self, *awards):
  654.         rows = []
  655.         table = []
  656.         for i, award in enumerate(awards):
  657.             name, count = award
  658.             rows.append(name)
  659.             table.append([count])
  660.  
  661.         awards_table = makeTable(row_names = rows, col_names = ['col_Count'],
  662.                                               table = table)
  663.         self.updateCurrentMissionLocal({'AwardsList':awards_table})
  664.  
  665.     def saveKilled(self, killed):
  666.         self.updateCurrentMissionLocal({'ClientStatus':['killed', 'landed'][not killed]})
  667.  
  668.     def saveMissionStatus(self, value):
  669.         self.updateCurrentMissionLocal({'MissionStatus':value})
  670.  
  671.     def setKillboard(self, rows = [], cols = [], table = []):
  672.         table = makeTable(row_names = rows, col_names = cols, table = table)
  673.         self.updateCurrentMission({'KillBoard':table})
  674.  
  675.     def getProfilePath(self, name):
  676.         return self.profiles_folder.createPath(name+'.epp')
  677.         
  678.     def setProfileAccessDenied(self, profile_name):
  679.         profile_path = self.getProfilePath(profile_name)
  680.         os.chmod(profile_path, os.R_OK)
  681.  
  682.     def setProfileAccessGranted(self, profile_name):
  683.         profile_path = self.getProfilePath(profile_name)
  684.         os.chmod(profile_path, 0666)
  685.  
  686.     def openProfile(self, name):
  687.         p = UDB.open(self.getProfilePath(name), 0)
  688.         return p
  689.  
  690.     def saveProfile(self, name, db):
  691.         UDB.save(self.getProfilePath(name), db)
  692.  
  693.     def copyProfile(self, src, dst):
  694.         self.saveProfile(dst, self.openProfile(src))
  695.  
  696.     def unlinkProfile(self, name):
  697.         os.remove(self.getProfilePath(name))
  698.  
  699.     def sleep(self, sec):
  700.         import time
  701.         time.sleep(sec)
  702.  
  703.     def openGameset(self, name):
  704.         return UDB.open(self.fullGamesetPath(name), 1)
  705.  
  706.     def sendKeys(self, *keys):
  707.         self.ctrls.captured_keys = keys
  708.         self.ctrls.pressed_keys = keys
  709.         self.update()
  710.  
  711.     def sendPressedKeys(self, *keys):
  712.         self.ctrls.pressed_keys = keys
  713.         self.update()
  714.         self.ctrls.pressed_keys = []
  715.  
  716.     def setNetworkSupported(self, is_supported):
  717.         self.Game._is_network_supported = is_supported
  718.         
  719.     def ServerInfo(self, s):
  720.         class ServerInfo:
  721.             name = s['ServerName']
  722.             type = s['ServerType']
  723.             ping = s['ServerPing']
  724.             num_players = s['ServerPlayers']
  725.             num_players_max = s['ServerPlayersMax']
  726.             campaign = s['CampaignTitle']
  727.             mission = s['MissionTitle']
  728.             mission_type = s['MissionType']
  729.             addr = s['addr']
  730.         return ServerInfo
  731.  
  732.     def ServerInfos(self, server_infos):
  733.         return map(self.ServerInfo, server_infos)
  734.  
  735.     def setServersList(self, *server_infos):
  736.         self.Game.servers = self.ServerInfos(server_infos)
  737.  
  738.     def addServers(self, *server_infos):
  739.         map(self.menu.addServer, self.ServerInfos(server_infos))
  740.         self.update()
  741.  
  742.     def onConnect(self, gmst, msn):
  743.         self.menu.onConnect(gmst, msn)
  744.         self.update()
  745.  
  746.     def onError(self, error):
  747.         self.menu.onError(error)
  748.         self.update()
  749.  
  750.     def showExitScreen(self, restart_enabled):
  751.         self.menu.showExitScreen(restart_enabled)
  752.         self.update()
  753.         
  754.     def onServerReady(self):
  755.         self.menu.onServerReady()
  756.         self.update()
  757.  
  758.     def setL10nData(self, folder, key, format):
  759.         self.text.data = mergeTrees({folder:{key:format}}, self.text.data)
  760.  
  761.     def setVideo(self, video_name):
  762.         self.Game.Video = video_name
  763.